/**
 * @file iec104_controller_main.c
 * @brief IoT平台与IEC 104协议控制器应用主程序
 * @details 实现MQTT平台与IEC 104设备之间的双向通信控制器
 * 
 * @author zyb
 * @date 2025-10-30
 * @version 1.0
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <signal.h>
#include <unistd.h>
#include <stdbool.h>
#include <time.h>
#include <pthread.h>
#include "../../../../common/logs/include/logger.h"
#include "../../../../app/common/mqtt/include/mqtt_client.h"
#include "../../../../app/common/mqtt/include/mqtt_config_loader.h"
#include "../../../../app/iotplatform/include/platform_client.h"
#include "../../../../app/iotplatform/include/platform_config.h"
#include "../include/iec104_protocol_bridge.h"
#include "../include/iec104_controller_config.h"
#include "../core/common/utils/include/build_config.h"
#include <uuid/uuid.h>

// 日志模块名称
#define LOG_MODULE_NAME "IEC104_CONTROLLER_MAIN"

/* ==================== 辅助函数 ==================== */

/**
 * @brief 安全的字符串复制函数（避免strncpy截断警告）
 */
static inline void safe_strncpy(char *dest, const char *src, size_t dest_size) {
    if (dest == NULL || src == NULL || dest_size == 0) {
        return;
    }
    size_t src_len = strlen(src);
    size_t copy_len = (src_len < dest_size - 1) ? src_len : (dest_size - 1);
    memcpy(dest, src, copy_len);
    dest[copy_len] = '\0';
}

// 全局变量
static volatile bool g_running = true;
static mqtt_client_handle_t g_mqtt_client = NULL;
static iec104_protocol_bridge_handle_t g_bridge = NULL;
static platform_client_handle_t g_platform_client = NULL;
static iec104_controller_config_t g_iec104_config;
static mqtt_full_config_t g_mqtt_config;
static platform_full_config_t g_platform_config;
static pthread_t g_property_report_thread = 0;
static volatile bool g_property_report_running = false;

/* ==================== 信号处理 ==================== */

/**
 * @brief 信号处理函数
 */
static void signal_handler(int signo) {
    if (signo == SIGINT || signo == SIGTERM) {
        LOG_INFO(LOG_MODULE_NAME, "收到退出信号 %d，准备关闭...", signo);
        g_running = false;
    }
}

/**
 * @brief 设置信号处理
 */
static void setup_signal_handlers(void) {
    signal(SIGINT, signal_handler);
    signal(SIGTERM, signal_handler);
    signal(SIGPIPE, SIG_IGN); // 忽略SIGPIPE信号
}

/* ==================== 函数声明 ==================== */

/**
 * @brief 执行设备注册和上线流程
 */
static void perform_device_register(void);

/**
 * @brief 生成UUID字符串
 */
static void generate_uuid(char* uuid_str, size_t size);

/**
 * @brief 启动属性上报线程
 */
static void start_property_report_thread(void);

/**
 * @brief 停止属性上报线程
 */
static void stop_property_report_thread(void);

/**
 * @brief 服务调用回调函数
 * @details 处理平台下发的服务调用指令
 */
static void on_service_call(const char* id, const char* identifier, 
                           const void* input_params, size_t input_params_len,
                           void* user_data);

/* ==================== MQTT回调函数 ==================== */

/**
 * @brief MQTT消息接收回调
 */
static void on_mqtt_message(const char* topic, const uint8_t* payload, 
                           size_t payload_len, void* user_data) {
    (void)user_data; // 未使用
    
    LOG_INFO(LOG_MODULE_NAME, "收到MQTT消息");
    LOG_DEBUG(LOG_MODULE_NAME, "  主题: %s", topic);
    LOG_DEBUG(LOG_MODULE_NAME, "  长度: %zu", payload_len);
    
    if (payload_len > 0) {
        // 打印前100字节的内容（如果是文本）
        size_t print_len = payload_len > 100 ? 100 : payload_len;
        char* print_buf = (char*)malloc(print_len + 1);
        if (print_buf) {
            memcpy(print_buf, payload, print_len);
            print_buf[print_len] = '\0';
            LOG_DEBUG(LOG_MODULE_NAME, "  内容: %s%s", print_buf, 
                     payload_len > 100 ? "..." : "");
            free(print_buf);
        }
    }
    
    // 转发到协议桥接模块处理
    if (g_bridge) {
        iec104_protocol_bridge_handle_mqtt_message(g_bridge, topic, payload, payload_len);
    }
}

/**
 * @brief MQTT连接状态回调
 */
static void on_mqtt_status(mqtt_status_t status, void* user_data) {
    (void)user_data; // 未使用
    
    LOG_DEBUG(LOG_MODULE_NAME, "进入函数: on_mqtt_status");
    LOG_DEBUG(LOG_MODULE_NAME, "  状态值: %d", status);
    LOG_DEBUG(LOG_MODULE_NAME, "  user_data: %p", user_data);
    LOG_DEBUG(LOG_MODULE_NAME, "  g_mqtt_client: %p", g_mqtt_client);
    
    // 安全检查：如果g_mqtt_client为空，直接返回
    if (g_mqtt_client == NULL) {
        LOG_WARN(LOG_MODULE_NAME, "MQTT客户端为空，忽略状态回调");
        return;
    }
    
    const char* status_str = "UNKNOWN";
    switch (status) {
        case MQTT_STATUS_DISCONNECTED:
            status_str = "DISCONNECTED";
            break;
        case MQTT_STATUS_CONNECTING:
            status_str = "CONNECTING";
            break;
        case MQTT_STATUS_CONNECTED:
            status_str = "CONNECTED";
            break;
        case MQTT_STATUS_DISCONNECTING:
            status_str = "DISCONNECTING";
            break;
        case MQTT_STATUS_ERROR:
            status_str = "ERROR";
            break;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "MQTT状态转换: %s", status_str);
    LOG_INFO(LOG_MODULE_NAME, "MQTT状态变化: %s", status_str);
    
    // 如果连接成功，创建平台客户端并进行设备注册
    if (status == MQTT_STATUS_CONNECTED) {
        LOG_DEBUG(LOG_MODULE_NAME, "检查MQTT连接状态和客户端指针...");
        if (g_mqtt_client) {
            LOG_DEBUG(LOG_MODULE_NAME, "MQTT连接成功，准备创建平台客户端");
            LOG_INFO(LOG_MODULE_NAME, "========================================");
            LOG_INFO(LOG_MODULE_NAME, "MQTT连接成功，开始设备上线流程");
            LOG_INFO(LOG_MODULE_NAME, "严格按照文档步骤执行:");
            LOG_INFO(LOG_MODULE_NAME, "========================================");

            // 步骤1: 创建平台客户端（这会订阅回复主题）
            LOG_DEBUG(LOG_MODULE_NAME, "步骤1: 检查平台客户端是否已创建...");
            LOG_DEBUG(LOG_MODULE_NAME, "  g_platform_client: %p", g_platform_client);
            if (g_platform_client == NULL) {
                LOG_DEBUG(LOG_MODULE_NAME, "平台客户端未创建，开始创建...");
                LOG_DEBUG(LOG_MODULE_NAME, "步骤1: 创建平台客户端并订阅回复主题...");
                platform_client_config_t platform_config;
                memset(&platform_config, 0, sizeof(platform_config));
                platform_config.mqtt_client = g_mqtt_client;
                memcpy(&platform_config.device, &g_platform_config.device, sizeof(platform_device_info_t));

                LOG_DEBUG(LOG_MODULE_NAME, "  设备信息:");
                LOG_DEBUG(LOG_MODULE_NAME, "    产品Key: %s", platform_config.device.product_key);
                LOG_DEBUG(LOG_MODULE_NAME, "    设备名称: %s", platform_config.device.device_name);
                LOG_DEBUG(LOG_MODULE_NAME, "    设备Secret: %s",
                         strlen(platform_config.device.device_secret) > 0 ? "***已配置***" : "***未配置***");
                LOG_DEBUG(LOG_MODULE_NAME, "    产品Secret: %s",
                         strlen(platform_config.device.product_secret) > 0 ? "***已配置***" : "***未配置***");

                g_platform_client = platform_client_create(&platform_config);
                if (g_platform_client == NULL) {
                    LOG_ERROR(LOG_MODULE_NAME, "步骤1失败: 创建平台客户端失败");
                } else {
                    LOG_INFO(LOG_MODULE_NAME, "平台客户端创建成功");
                    
                    // 设置服务调用回调，处理平台下发的服务指令
                    platform_set_service_call_callback(g_platform_client, on_service_call, NULL);
                    LOG_INFO(LOG_MODULE_NAME, "服务调用回调已设置");
                }
            } else {
                LOG_DEBUG(LOG_MODULE_NAME, "平台客户端已存在，跳过创建");
            }

            // 等待订阅生效（MQTT订阅是异步的，需要等待确认）
            LOG_DEBUG(LOG_MODULE_NAME, "等待MQTT订阅生效（500ms）...");
            struct timespec sleep_time = {0, 500000000};  // 500ms
            nanosleep(&sleep_time, NULL);
            LOG_DEBUG(LOG_MODULE_NAME, "等待完成，确保订阅已生效");

            // 步骤2: 执行设备注册和上线流程
            LOG_DEBUG(LOG_MODULE_NAME, "步骤2: 准备执行设备注册和上线流程...");
            LOG_DEBUG(LOG_MODULE_NAME, "  g_platform_client: %p", g_platform_client);
            if (g_platform_client) {
                LOG_DEBUG(LOG_MODULE_NAME, "步骤2: 执行设备注册和上线流程...");
                perform_device_register();
                LOG_DEBUG(LOG_MODULE_NAME, "步骤2: perform_device_register调用完成");
            } else {
                LOG_ERROR(LOG_MODULE_NAME, "步骤2失败: 平台客户端未创建，无法执行设备注册");
                LOG_DEBUG(LOG_MODULE_NAME, "  原因: g_platform_client为NULL");
            }

            // 步骤3: 订阅控制主题（如果配置了）
            LOG_DEBUG(LOG_MODULE_NAME, "步骤3: 检查控制主题配置...");
            // 安全检查：检查topic_control是否为空字符串，以及g_mqtt_client是否为空
            size_t topic_len = strlen(g_mqtt_config.topic_control);
            LOG_DEBUG(LOG_MODULE_NAME, "  控制主题长度: %zu", topic_len);
            LOG_DEBUG(LOG_MODULE_NAME, "步骤3: 订阅控制主题（可选）...");
            if (topic_len > 0 && g_mqtt_client != NULL) {
                LOG_DEBUG(LOG_MODULE_NAME, "  主题: %s", g_mqtt_config.topic_control);
                LOG_DEBUG(LOG_MODULE_NAME, "  QoS: %d", g_mqtt_config.connection.qos);
                mqtt_client_subscribe(g_mqtt_client, g_mqtt_config.topic_control, 
                                     g_mqtt_config.connection.qos);
                LOG_DEBUG(LOG_MODULE_NAME, "控制主题订阅请求已发送");
                LOG_DEBUG(LOG_MODULE_NAME, "步骤3完成: 控制主题订阅成功");
            } else {
                if (topic_len == 0) {
                    LOG_DEBUG(LOG_MODULE_NAME, "控制主题未配置，跳过订阅");
                } else {
                    LOG_DEBUG(LOG_MODULE_NAME, "MQTT客户端为空，跳过订阅");
                }
            }
            
            LOG_DEBUG(LOG_MODULE_NAME, "========================================");
            LOG_INFO(LOG_MODULE_NAME, "设备上线流程初始化完成，等待平台回复...");
            LOG_DEBUG(LOG_MODULE_NAME, "========================================");
        } else {
            LOG_WARN(LOG_MODULE_NAME, "MQTT客户端为空，无法执行设备上线流程");
        }
    }
}

/**
 * @brief MQTT错误回调
 */
static void on_mqtt_error(mqtt_result_t error, void* user_data) {
    (void)user_data; // 未使用
    
    // 安全检查：避免在错误回调中访问可能为空的全局变量
    LOG_ERROR(LOG_MODULE_NAME, "MQTT错误: %d", error);
    
    // 错误码说明
    switch (error) {
        case -3:
            LOG_WARN(LOG_MODULE_NAME, "MQTT错误详情: 等待操作超时");
            break;
        case -1:
            LOG_WARN(LOG_MODULE_NAME, "MQTT错误详情: 连接失败");
            break;
        default:
            LOG_WARN(LOG_MODULE_NAME, "MQTT错误详情: 未知错误码");
            break;
    }
    
    // 不在这里进行重连，由主循环负责重连逻辑
}

/* ==================== 平台客户端回调函数 ==================== */

/**
 * @brief 生成UUID字符串
 */
static void generate_uuid(char* uuid_str, size_t size) {
    (void)size; // 参数未使用，避免警告
    uuid_t uuid;
    uuid_generate(uuid);
    uuid_unparse_lower(uuid, uuid_str);
}

/**
 * @brief 设备注册回复回调
 */
static void on_device_register_reply(const platform_device_register_reply_t* reply, void* user_data) {
    (void)user_data;
    
    LOG_DEBUG(LOG_MODULE_NAME, "进入函数: on_device_register_reply");
    LOG_DEBUG(LOG_MODULE_NAME, "  reply: %p", reply);
    LOG_DEBUG(LOG_MODULE_NAME, "  user_data: %p", user_data);
    
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    LOG_INFO(LOG_MODULE_NAME, "收到设备注册/上线回复");
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    
    if (reply == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "设备注册回复为空");
        return;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "回复详情:");
    LOG_DEBUG(LOG_MODULE_NAME, "  消息ID: %s", reply->id);
    LOG_DEBUG(LOG_MODULE_NAME, "  类型: %s", reply->type);
    LOG_DEBUG(LOG_MODULE_NAME, "  结果: %s", reply->code);
    
    if (strcmp(reply->code, "success") == 0) {
        LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
        LOG_INFO(LOG_MODULE_NAME, "设备注册成功，设备已上线");
        LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
        if (strlen(reply->cloud_time) > 0) {
            LOG_INFO(LOG_MODULE_NAME, "云端时间: %s", reply->cloud_time);
        }
        LOG_INFO(LOG_MODULE_NAME, "提示: 请在平台界面查看设备状态，应该显示为在线");
        
        // 启动属性上报线程
        start_property_report_thread();
    } else {
        LOG_ERROR(LOG_MODULE_NAME, "----------------------------------------");
        LOG_ERROR(LOG_MODULE_NAME, "设备注册失败");
        LOG_ERROR(LOG_MODULE_NAME, "----------------------------------------");
        LOG_ERROR(LOG_MODULE_NAME, "失败原因: %s", reply->reason);
        LOG_ERROR(LOG_MODULE_NAME, "提示: 请检查:");
        LOG_ERROR(LOG_MODULE_NAME, "  1. 设备名称是否正确");
        LOG_ERROR(LOG_MODULE_NAME, "  2. 产品Key是否正确");
        LOG_ERROR(LOG_MODULE_NAME, "  3. 设备Secret是否正确");
        LOG_ERROR(LOG_MODULE_NAME, "  4. 平台上的设备是否已创建");
    }
    LOG_INFO(LOG_MODULE_NAME, "========================================");
}

/**
 * @brief 服务调用回调函数
 * @details 处理平台下发的服务调用指令
 * 支持的服务：
 * - PCS_2_2_R_E: PCS_2_2_远程停机指令
 * - PCS_2_2_R_S: PCS_2_2_远程启动指令
 */
static void on_service_call(const char* id, const char* identifier, 
                           const void* input_params, size_t input_params_len,
                           void* user_data) {
    (void)user_data;
    
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    LOG_INFO(LOG_MODULE_NAME, "收到服务调用指令");
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    LOG_INFO(LOG_MODULE_NAME, "  消息ID: %s", id);
    LOG_INFO(LOG_MODULE_NAME, "  服务标识符: %s", identifier);
    
    if (input_params != NULL && input_params_len > 0) {
        char* params_str = (char*)malloc(input_params_len + 1);
        if (params_str) {
            memcpy(params_str, input_params, input_params_len);
            params_str[input_params_len] = '\0';
            LOG_INFO(LOG_MODULE_NAME, "  输入参数: %s", params_str);
            free(params_str);
        }
    }
    
    // 检查服务标识符并执行相应操作
    if (strcmp(identifier, "PCS_2_2_R_E") == 0) {
        // PCS_2_2_远程停机指令
        LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
        LOG_INFO(LOG_MODULE_NAME, "执行服务: PCS_2_2_远程停机指令");
        LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
        
        // 通过104协议发送停机指令
        if (g_bridge != NULL) {
            // 发送远程停机指令（信息对象地址: 2, 命令值: false表示停机）
            int result = iec104_protocol_bridge_send_command(g_bridge, 2, false);
            if (result == 0) {
                LOG_INFO(LOG_MODULE_NAME, "✓ 远程停机指令发送成功");
                
                // 回复服务调用结果（成功）
                char output_params[256] = "{\"result\":\"success\",\"message\":\"远程停机指令已执行\"}";
                platform_service_report(g_platform_client, id, identifier, 
                                       (const char*)input_params, output_params);
                LOG_INFO(LOG_MODULE_NAME, "服务调用结果已上报: 成功");
            } else {
                LOG_ERROR(LOG_MODULE_NAME, "✗ 远程停机指令发送失败");
                
                // 回复服务调用结果（失败）
                char output_params[256] = "{\"result\":\"fail\",\"message\":\"远程停机指令执行失败\"}";
                platform_service_report(g_platform_client, id, identifier, 
                                       (const char*)input_params, output_params);
                LOG_ERROR(LOG_MODULE_NAME, "服务调用结果已上报: 失败");
            }
        } else {
            LOG_ERROR(LOG_MODULE_NAME, "104协议桥接模块未初始化，无法执行指令");
            char output_params[256] = "{\"result\":\"fail\",\"message\":\"104协议桥接模块未初始化\"}";
            platform_service_report(g_platform_client, id, identifier, 
                                   (const char*)input_params, output_params);
        }
        
    } else if (strcmp(identifier, "PCS_2_2_R_S") == 0) {
        // PCS_2_2_远程启动指令
        LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
        LOG_INFO(LOG_MODULE_NAME, "执行服务: PCS_2_2_远程启动指令");
        LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
        
        // 通过104协议发送启动指令
        if (g_bridge != NULL) {
            // 发送远程启动指令（信息对象地址: 2, 命令值: true表示启动）
            int result = iec104_protocol_bridge_send_command(g_bridge, 2, true);
            if (result == 0) {
                LOG_INFO(LOG_MODULE_NAME, "✓ 远程启动指令发送成功");
                
                // 回复服务调用结果（成功）
                char output_params[256] = "{\"result\":\"success\",\"message\":\"远程启动指令已执行\"}";
                platform_service_report(g_platform_client, id, identifier, 
                                       (const char*)input_params, output_params);
                LOG_INFO(LOG_MODULE_NAME, "服务调用结果已上报: 成功");
            } else {
                LOG_ERROR(LOG_MODULE_NAME, "✗ 远程启动指令发送失败");
                
                // 回复服务调用结果（失败）
                char output_params[256] = "{\"result\":\"fail\",\"message\":\"远程启动指令执行失败\"}";
                platform_service_report(g_platform_client, id, identifier, 
                                       (const char*)input_params, output_params);
                LOG_ERROR(LOG_MODULE_NAME, "服务调用结果已上报: 失败");
            }
        } else {
            LOG_ERROR(LOG_MODULE_NAME, "104协议桥接模块未初始化，无法执行指令");
            char output_params[256] = "{\"result\":\"fail\",\"message\":\"104协议桥接模块未初始化\"}";
            platform_service_report(g_platform_client, id, identifier, 
                                   (const char*)input_params, output_params);
        }
        
    } else {
        LOG_WARN(LOG_MODULE_NAME, "未知的服务标识符: %s", identifier);
        char output_params[256] = "{\"result\":\"fail\",\"message\":\"未知的服务标识符\"}";
        platform_service_report(g_platform_client, id, identifier, 
                               (const char*)input_params, output_params);
    }
    
    LOG_INFO(LOG_MODULE_NAME, "========================================");
}

/**
 * @brief 设备主动注册回复回调
 */
static void on_device_signup_reply(const platform_device_signup_reply_t* reply, void* user_data) {
    (void)user_data;
    
    LOG_DEBUG(LOG_MODULE_NAME, "进入函数: on_device_signup_reply");
    LOG_DEBUG(LOG_MODULE_NAME, "  reply: %p", reply);
    LOG_DEBUG(LOG_MODULE_NAME, "  user_data: %p", user_data);
    
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    LOG_INFO(LOG_MODULE_NAME, "收到设备主动注册回复");
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    
    if (reply == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "设备主动注册回复为空");
        return;
    }
    
    LOG_DEBUG(LOG_MODULE_NAME, "回复详情:");
    LOG_DEBUG(LOG_MODULE_NAME, "  消息ID: %s", reply->id);
    LOG_DEBUG(LOG_MODULE_NAME, "  类型: %s", reply->type);
    LOG_DEBUG(LOG_MODULE_NAME, "  结果: %s", reply->code);
    
    if (strcmp(reply->code, "success") == 0) {
        LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
        LOG_INFO(LOG_MODULE_NAME, "设备主动注册成功");
        LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
        LOG_INFO(LOG_MODULE_NAME, "返回的设备信息:");
        LOG_INFO(LOG_MODULE_NAME, "  产品Key: %s", reply->product_key);
        LOG_INFO(LOG_MODULE_NAME, "  设备名称: %s", reply->device_name);
        LOG_INFO(LOG_MODULE_NAME, "  设备Secret: %s", reply->device_secret);
        
        // 注册成功后，更新配置中的device_secret（如果需要）
        // 然后立即进行设备上线（register）
        if (g_platform_client) {
            LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
            LOG_INFO(LOG_MODULE_NAME, "设备主动注册成功，立即执行设备上线（register）...");
            LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
            
            platform_device_register_req_t register_req;
            memset(&register_req, 0, sizeof(register_req));
            generate_uuid(register_req.id, sizeof(register_req.id));
            safe_strncpy(register_req.type, "register", sizeof(register_req.type));
            safe_strncpy(register_req.device.product_key, reply->product_key, sizeof(register_req.device.product_key));
            safe_strncpy(register_req.device.device_name, reply->device_name, sizeof(register_req.device.device_name));
            safe_strncpy(register_req.device.device_secret, reply->device_secret, sizeof(register_req.device.device_secret));
            
            LOG_INFO(LOG_MODULE_NAME, "设备上线请求内容:");
            LOG_INFO(LOG_MODULE_NAME, "  消息ID: %s", register_req.id);
            LOG_INFO(LOG_MODULE_NAME, "  类型: %s", register_req.type);
            LOG_INFO(LOG_MODULE_NAME, "  产品Key: %s", register_req.device.product_key);
            LOG_INFO(LOG_MODULE_NAME, "  设备名称: %s", register_req.device.device_name);
            LOG_INFO(LOG_MODULE_NAME, "  设备Secret: ***已配置***");
            
            platform_result_t result = platform_device_register(g_platform_client, &register_req, on_device_register_reply, NULL);
            if (result != PLATFORM_SUCCESS) {
                LOG_ERROR(LOG_MODULE_NAME, "设备上线请求发送失败，错误码: %d", result);
            } else {
                LOG_INFO(LOG_MODULE_NAME, "设备上线请求已发送，等待平台回复...");
            }
        } else {
            LOG_ERROR(LOG_MODULE_NAME, "平台客户端未初始化，无法执行设备上线");
        }
    } else {
        LOG_ERROR(LOG_MODULE_NAME, "----------------------------------------");
        LOG_ERROR(LOG_MODULE_NAME, "设备主动注册失败");
        LOG_ERROR(LOG_MODULE_NAME, "----------------------------------------");
        LOG_ERROR(LOG_MODULE_NAME, "失败原因: %s", reply->msg);
        LOG_ERROR(LOG_MODULE_NAME, "提示: 请检查:");
        LOG_ERROR(LOG_MODULE_NAME, "  1. 产品Key是否正确");
        LOG_ERROR(LOG_MODULE_NAME, "  2. 产品Secret是否正确");
        LOG_ERROR(LOG_MODULE_NAME, "  3. 设备名称是否已存在或格式是否正确");
    }
    LOG_INFO(LOG_MODULE_NAME, "========================================");
}

/**
 * @brief 执行设备注册和上线流程
 */
static void perform_device_register(void) {
    LOG_DEBUG(LOG_MODULE_NAME, "----------------------------------------");
    LOG_DEBUG(LOG_MODULE_NAME, "进入函数: perform_device_register");
    LOG_DEBUG(LOG_MODULE_NAME, "----------------------------------------");
    
    LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
    LOG_INFO(LOG_MODULE_NAME, "开始执行设备注册和上线流程");
    LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
    
    LOG_DEBUG(LOG_MODULE_NAME, "检查客户端状态...");
    LOG_DEBUG(LOG_MODULE_NAME, "  g_platform_client: %p", g_platform_client);
    LOG_DEBUG(LOG_MODULE_NAME, "  g_mqtt_client: %p", g_mqtt_client);
    
    if (g_platform_client == NULL || g_mqtt_client == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "平台客户端或MQTT客户端未初始化，无法进行设备注册");
        LOG_DEBUG(LOG_MODULE_NAME, "  平台客户端: %s", g_platform_client ? "已初始化" : "未初始化");
        LOG_DEBUG(LOG_MODULE_NAME, "  MQTT客户端: %s", g_mqtt_client ? "已初始化" : "未初始化");
        LOG_DEBUG(LOG_MODULE_NAME, "函数退出: perform_device_register (失败)");
        return;
    }
    LOG_DEBUG(LOG_MODULE_NAME, "客户端状态检查通过");
    
    // 检查设备信息是否完整
    LOG_DEBUG(LOG_MODULE_NAME, "检查设备信息完整性...");
    LOG_DEBUG(LOG_MODULE_NAME, "  产品Key长度: %zu", strlen(g_platform_config.device.product_key));
    LOG_DEBUG(LOG_MODULE_NAME, "  设备名称长度: %zu", strlen(g_platform_config.device.device_name));
    LOG_DEBUG(LOG_MODULE_NAME, "  设备Secret长度: %zu", strlen(g_platform_config.device.device_secret));
    LOG_DEBUG(LOG_MODULE_NAME, "  产品Secret长度: %zu", strlen(g_platform_config.device.product_secret));
    LOG_INFO(LOG_MODULE_NAME, "  产品Key: [%s] %s", 
             g_platform_config.device.product_key,
             strlen(g_platform_config.device.product_key) > 0 ? "成功" : "缺失");
    LOG_INFO(LOG_MODULE_NAME, "  设备名称: [%s] %s",
             g_platform_config.device.device_name,
             strlen(g_platform_config.device.device_name) > 0 ? "成功" : "缺失");
    LOG_INFO(LOG_MODULE_NAME, "  设备Secret: %s",
             strlen(g_platform_config.device.device_secret) > 0 ? "已配置" : " 未配置");
    LOG_INFO(LOG_MODULE_NAME, "  产品Secret: %s",
             strlen(g_platform_config.device.product_secret) > 0 ? "已配置" : " 未配置");
    
    if (strlen(g_platform_config.device.product_key) == 0 ||
        strlen(g_platform_config.device.device_name) == 0) {
        LOG_ERROR(LOG_MODULE_NAME, "设备信息不完整，无法进行设备注册");
        LOG_DEBUG(LOG_MODULE_NAME, "设备信息检查失败，函数退出");
        LOG_DEBUG(LOG_MODULE_NAME, "函数退出: perform_device_register (失败)");
        return;
    }
    LOG_DEBUG(LOG_MODULE_NAME, "设备基本信息检查通过");
    
    // 如果device_secret为空，说明设备还没有注册，需要先进行主动注册（signup）
    LOG_DEBUG(LOG_MODULE_NAME, "检查device_secret状态...");
    if (strlen(g_platform_config.device.device_secret) == 0) {
        LOG_DEBUG(LOG_MODULE_NAME, "device_secret为空，需要执行signup流程");
        LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
        LOG_INFO(LOG_MODULE_NAME, "检测到设备Secret为空，执行主动注册（signup）...");
        LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
        
        LOG_DEBUG(LOG_MODULE_NAME, "检查product_secret是否配置...");
        if (strlen(g_platform_config.device.product_secret) == 0) {
            LOG_ERROR(LOG_MODULE_NAME, "产品Secret为空，无法执行主动注册");
            LOG_DEBUG(LOG_MODULE_NAME, "  提示: 主动注册需要product_secret，请检查配置文件");
            LOG_DEBUG(LOG_MODULE_NAME, "函数退出: perform_device_register (失败)");
            return;
        }
        LOG_DEBUG(LOG_MODULE_NAME, "product_secret已配置，准备构建signup请求");
        
        platform_device_signup_req_t signup_req;
        memset(&signup_req, 0, sizeof(signup_req));
        LOG_DEBUG(LOG_MODULE_NAME, "生成signup请求UUID...");
        generate_uuid(signup_req.id, sizeof(signup_req.id));
        LOG_DEBUG(LOG_MODULE_NAME, "生成的UUID: %s", signup_req.id);
        safe_strncpy(signup_req.type, "signup", sizeof(signup_req.type));
        safe_strncpy(signup_req.product_key, g_platform_config.device.product_key, sizeof(signup_req.product_key));
        safe_strncpy(signup_req.product_secret, g_platform_config.device.product_secret, sizeof(signup_req.product_secret));
        safe_strncpy(signup_req.device_name, g_platform_config.device.device_name, sizeof(signup_req.device_name));
        
        LOG_DEBUG(LOG_MODULE_NAME, "构建signup请求完成，准备发送");
        LOG_DEBUG(LOG_MODULE_NAME, "主动注册请求内容:");
        LOG_DEBUG(LOG_MODULE_NAME, "  消息ID: %s", signup_req.id);
        LOG_DEBUG(LOG_MODULE_NAME, "  类型: %s", signup_req.type);
        LOG_DEBUG(LOG_MODULE_NAME, "  产品Key: %s", signup_req.product_key);
        LOG_DEBUG(LOG_MODULE_NAME, "  设备名称: %s", signup_req.device_name);
        LOG_DEBUG(LOG_MODULE_NAME, "  产品Secret: ***已配置***");
        
        LOG_DEBUG(LOG_MODULE_NAME, "调用platform_device_signup发送signup请求...");
        platform_result_t result = platform_device_signup(g_platform_client, &signup_req, on_device_signup_reply, NULL);
        LOG_DEBUG(LOG_MODULE_NAME, "platform_device_signup返回结果: %d", result);
        if (result != PLATFORM_SUCCESS) {
            LOG_ERROR(LOG_MODULE_NAME, "设备主动注册请求发送失败，错误码: %d", result);
        } else {
            LOG_INFO(LOG_MODULE_NAME, "设备主动注册请求已发送，等待平台回复...");
            LOG_DEBUG(LOG_MODULE_NAME, "  提示: 如果注册成功，将自动执行设备上线");
        }
        LOG_DEBUG(LOG_MODULE_NAME, "signup流程完成，函数退出（等待回调）");
        LOG_DEBUG(LOG_MODULE_NAME, "函数退出: perform_device_register (成功，等待signup回复)");
        return;
    } else {
        // 设备已经有device_secret，直接进行设备上线（register）
        LOG_DEBUG(LOG_MODULE_NAME, "device_secret已配置，直接执行register流程");
        LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
        LOG_INFO(LOG_MODULE_NAME, "检测到设备Secret已配置，执行设备上线（register）...");
        LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
        
        LOG_DEBUG(LOG_MODULE_NAME, "准备构建register请求...");
        platform_device_register_req_t register_req;
        memset(&register_req, 0, sizeof(register_req));
        LOG_DEBUG(LOG_MODULE_NAME, "生成register请求UUID...");
        generate_uuid(register_req.id, sizeof(register_req.id));
        LOG_DEBUG(LOG_MODULE_NAME, "生成的UUID: %s", register_req.id);
        safe_strncpy(register_req.type, "register", sizeof(register_req.type));
        safe_strncpy(register_req.device.product_key, g_platform_config.device.product_key, sizeof(register_req.device.product_key));
        safe_strncpy(register_req.device.device_name, g_platform_config.device.device_name, sizeof(register_req.device.device_name));
        safe_strncpy(register_req.device.device_secret, g_platform_config.device.device_secret, sizeof(register_req.device.device_secret));
        LOG_DEBUG(LOG_MODULE_NAME, "register请求构建完成");
        
        LOG_DEBUG(LOG_MODULE_NAME, "设备上线请求内容:");
        LOG_DEBUG(LOG_MODULE_NAME, "  消息ID: %s", register_req.id);
        LOG_DEBUG(LOG_MODULE_NAME, "  类型: %s", register_req.type);
        LOG_DEBUG(LOG_MODULE_NAME, "  产品Key: %s", register_req.device.product_key);
        LOG_DEBUG(LOG_MODULE_NAME, "  设备名称: %s", register_req.device.device_name);
        LOG_DEBUG(LOG_MODULE_NAME, "  设备Secret: ***已配置***");
        
        LOG_DEBUG(LOG_MODULE_NAME, "调用platform_device_register发送register请求...");
        platform_result_t result = platform_device_register(g_platform_client, &register_req, on_device_register_reply, NULL);
        LOG_DEBUG(LOG_MODULE_NAME, "platform_device_register返回结果: %d", result);
        if (result != PLATFORM_SUCCESS) {
            LOG_ERROR(LOG_MODULE_NAME, "设备上线请求发送失败，错误码: %d", result);
            LOG_DEBUG(LOG_MODULE_NAME, "函数退出: perform_device_register (失败，发送register请求失败)");
        } else {
            LOG_INFO(LOG_MODULE_NAME, "设备上线请求已发送，等待平台回复...");
            LOG_DEBUG(LOG_MODULE_NAME, "register流程完成，函数退出（等待回调）");
            LOG_DEBUG(LOG_MODULE_NAME, "函数退出: perform_device_register (成功，等待register回复)");
        }
    }
    LOG_INFO(LOG_MODULE_NAME, "----------------------------------------");
}

/* ==================== 初始化和清理 ==================== */

/**
 * @brief 初始化控制器应用
 */
static int gateway_init(const char* mqtt_config_file, const char* iec104_config_file) {
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    LOG_INFO(LOG_MODULE_NAME, "IoT平台与104协议控制器启动");
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    
    // 加载MQTT配置（可选，失败不影响程序运行）
    LOG_DEBUG(LOG_MODULE_NAME, "加载MQTT配置文件: %s", mqtt_config_file);
    if (mqtt_config_load(&g_mqtt_config, mqtt_config_file) != 0) {
        LOG_WARN(LOG_MODULE_NAME, "加载MQTT配置文件失败，MQTT功能将不可用");
        memset(&g_mqtt_config, 0, sizeof(g_mqtt_config));
    } else {
        mqtt_config_print(&g_mqtt_config);
    }
    
    // 加载平台配置（可选）
    LOG_DEBUG(LOG_MODULE_NAME, "加载平台配置文件: %s", mqtt_config_file);
    if (platform_config_load(&g_platform_config, mqtt_config_file) != 0) {
        LOG_WARN(LOG_MODULE_NAME, "加载平台配置文件失败，使用默认值");
        memset(&g_platform_config, 0, sizeof(g_platform_config));
        if (g_mqtt_config.connection.broker[0] != '\0') {
            memcpy(&g_platform_config.mqtt, &g_mqtt_config.connection, sizeof(mqtt_config_t));
        }
    } else {
        LOG_DEBUG(LOG_MODULE_NAME, "平台配置加载成功");
        platform_config_print(&g_platform_config);
    }
    
    // 加载104控制器配置（必需）
    LOG_DEBUG(LOG_MODULE_NAME, "加载104控制器配置文件: %s", iec104_config_file);
    if (iec104_controller_config_load(&g_iec104_config, iec104_config_file) != 0) {
        LOG_ERROR(LOG_MODULE_NAME, "加载104控制器配置文件失败");
        return -1;
    }
    iec104_controller_config_print(&g_iec104_config);
    
    // 初始化MQTT模块（可选）
    if (g_mqtt_config.connection.broker[0] != '\0') {
        // 如果Client ID为空，根据ProductKey和DeviceName自动生成
        if (g_mqtt_config.connection.client_id[0] == '\0' && 
            g_platform_config.device.product_key[0] != '\0' && 
            g_platform_config.device.device_name[0] != '\0') {
            // 计算所需长度，确保不会截断
            size_t key_len = strlen(g_platform_config.device.product_key);
            size_t name_len = strlen(g_platform_config.device.device_name);
            size_t total_len = key_len + 1 + name_len;  // key + '.' + name
            size_t max_len = sizeof(g_mqtt_config.connection.client_id) - 1;
            
            if (total_len <= max_len) {
                // 使用安全的字符串拼接方式，避免编译器截断警告
                char* dest = g_mqtt_config.connection.client_id;
                size_t buf_size = sizeof(g_mqtt_config.connection.client_id);
                
                // 复制 product_key
                size_t copied = key_len;
                if (copied >= buf_size) copied = buf_size - 1;
                memcpy(dest, g_platform_config.device.product_key, copied);
                dest += copied;
                buf_size -= copied;
                
                // 添加 '.'
                if (buf_size > 1) {
                    *dest++ = '.';
                    buf_size--;
                }
                
                // 复制 device_name
                if (buf_size > 1) {
                    size_t name_copied = name_len;
                    if (name_copied >= buf_size) name_copied = buf_size - 1;
                    memcpy(dest, g_platform_config.device.device_name, name_copied);
                    dest += name_copied;
                    *dest = '\0';  // 确保字符串结束
                } else {
                    *(dest - 1) = '\0';  // 如果空间不足，确保字符串结束
                }
                
                LOG_INFO(LOG_MODULE_NAME, "自动生成MQTT Client ID: %s", g_mqtt_config.connection.client_id);
            } else {
                LOG_WARN(LOG_MODULE_NAME, "Client ID长度超限，无法自动生成 (需要%zu字节，最大%zu字节)", 
                        total_len, max_len);
            }
        }
        
        // 如果MQTT配置中没有用户名/密码，尝试从平台配置中获取
        if (g_mqtt_config.connection.username[0] == '\0' && 
            g_platform_config.mqtt.username[0] != '\0') {
            safe_strncpy(g_mqtt_config.connection.username, 
                        g_platform_config.mqtt.username,
                        sizeof(g_mqtt_config.connection.username));
        }
        if (g_mqtt_config.connection.password[0] == '\0' && 
            g_platform_config.mqtt.password[0] != '\0') {
            safe_strncpy(g_mqtt_config.connection.password, 
                        g_platform_config.mqtt.password,
                        sizeof(g_mqtt_config.connection.password));
        }
        
        LOG_INFO(LOG_MODULE_NAME, "初始化MQTT模块");
        if (mqtt_init() != MQTT_SUCCESS) {
            LOG_WARN(LOG_MODULE_NAME, "MQTT模块初始化失败，MQTT功能将不可用");
            g_mqtt_client = NULL;
        } else {
            // 创建MQTT客户端
            LOG_INFO(LOG_MODULE_NAME, "创建MQTT客户端");
            g_mqtt_client = mqtt_client_create(&g_mqtt_config.connection);
            if (g_mqtt_client == NULL) {
                LOG_WARN(LOG_MODULE_NAME, "创建MQTT客户端失败，MQTT功能将不可用");
            } else {
                // 设置MQTT回调
                mqtt_client_set_message_callback(g_mqtt_client, on_mqtt_message, NULL);
                mqtt_client_set_status_callback(g_mqtt_client, on_mqtt_status, NULL);
                mqtt_client_set_error_callback(g_mqtt_client, on_mqtt_error, NULL);
                
                // 尝试连接MQTT Broker（非必需，失败时继续运行）
                LOG_INFO(LOG_MODULE_NAME, "连接MQTT Broker");
                if (mqtt_client_connect(g_mqtt_client) != MQTT_SUCCESS) {
                    LOG_WARN(LOG_MODULE_NAME, "连接MQTT Broker失败，但程序将继续运行（MQTT为可选功能）");
                } else {
                    LOG_INFO(LOG_MODULE_NAME, "MQTT Broker连接成功");
                }
            }
        }
    } else {
        LOG_INFO(LOG_MODULE_NAME, "MQTT配置未加载，跳过MQTT初始化");
        g_mqtt_client = NULL;
    }
    
    // 创建协议桥接
    LOG_DEBUG(LOG_MODULE_NAME, "创建协议桥接模块");
    iec104_protocol_bridge_config_t bridge_config;
    memset(&bridge_config, 0, sizeof(iec104_protocol_bridge_config_t));
    safe_strncpy(bridge_config.device_ip, g_iec104_config.device_ip, sizeof(bridge_config.device_ip));
    bridge_config.device_port = g_iec104_config.device_port;
    bridge_config.data_report_interval = g_mqtt_config.data_report_interval > 0 ? 
                                        g_mqtt_config.data_report_interval : 5;
    bridge_config.mqtt_client = g_mqtt_client;  // 可能为NULL
    safe_strncpy(bridge_config.mqtt_topic_data, g_mqtt_config.topic_data,
                 sizeof(bridge_config.mqtt_topic_data));
    safe_strncpy(bridge_config.mqtt_topic_status, g_mqtt_config.topic_status,
                 sizeof(bridge_config.mqtt_topic_status));
    safe_strncpy(bridge_config.mqtt_topic_alarm, g_mqtt_config.topic_alarm,
                 sizeof(bridge_config.mqtt_topic_alarm));
    
    g_bridge = iec104_protocol_bridge_create(&bridge_config);
    if (g_bridge == NULL) {
        LOG_ERROR(LOG_MODULE_NAME, "创建协议桥接模块失败");
        if (g_mqtt_client) {
            mqtt_client_disconnect(g_mqtt_client);
            mqtt_client_destroy(g_mqtt_client);
            mqtt_cleanup();
        }
        return -1;
    }
    
    // 检查是否配置了104设备IP，如果未配置则跳过连接
    if (g_iec104_config.device_ip[0] == '\0' || 
        strlen(g_iec104_config.device_ip) == 0 ||
        strcmp(g_iec104_config.device_ip, "0.0.0.0") == 0) {
        LOG_INFO(LOG_MODULE_NAME, "104设备IP未配置，跳过104设备连接（程序将以MQTT模式运行）");
        LOG_DEBUG(LOG_MODULE_NAME, "提示: 如需连接104设备，请在配置文件中设置device_ip");
    } else {
        // 启动协议桥接（尝试连接104设备）
        LOG_INFO(LOG_MODULE_NAME, "启动协议桥接模块，正在尝试连接104设备: %s:%u", 
                 g_iec104_config.device_ip, g_iec104_config.device_port);
        if (iec104_protocol_bridge_start(g_bridge) != 0) {
            LOG_ERROR(LOG_MODULE_NAME, "启动协议桥接模块失败");
            // 启动失败是严重错误，但程序可以继续运行（仅MQTT模式）
        } else {
            // 协议桥接服务已启动，连接状态会在connect_to_device函数中打印
            // 如果连接失败，会在监控线程中每5分钟重试
            LOG_DEBUG(LOG_MODULE_NAME, "协议桥接服务已启动，连接状态请查看后续日志");
        }
    }
    
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    LOG_INFO(LOG_MODULE_NAME, "控制器启动成功");
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    
    return 0;
}

/**
 * @brief 清理控制器应用
 */
/**
 * @brief 属性上报线程函数
 * @details 每1分钟上报一次104协议真实数据到IoT平台
 * 
 * TODO: 需要实现以下功能：
 * 1. 从104协议桥接模块（g_bridge）获取最新的遥测/遥信数据
 * 2. 将104协议数据转换为平台属性格式（JSON）
 *    - 根据平台物模型中定义的属性标识符进行映射
 *    - 数据格式: {"属性标识符": "属性值"}
 * 3. 调用 platform_property_post() 上报到平台
 * 
 * 实现思路：
 * - 可以通过104桥接模块的回调机制接收数据
 * - 或者在桥接模块中维护一个数据缓存，定期读取
 * - 需要处理数据类型映射（遥测、遥信等转换为平台属性）
 */
static void* property_report_thread_func(void* arg) {
    (void)arg;  // 未使用的参数
    LOG_INFO(LOG_MODULE_NAME, "属性上报线程启动");
    
    while (g_property_report_running && g_running) {
        // 等待1分钟（60秒）
        struct timespec sleep_time = {60, 0};  // 60秒
        nanosleep(&sleep_time, NULL);
        
        if (!g_property_report_running || !g_running) {
            break;
        }
        
        // 检查平台客户端是否可用
        if (g_platform_client == NULL) {
            LOG_DEBUG(LOG_MODULE_NAME, "平台客户端未初始化，跳过属性上报");
            continue;
        }
        
        // 检查MQTT连接状态
        if (g_mqtt_client == NULL || !mqtt_client_is_connected(g_mqtt_client)) {
            LOG_DEBUG(LOG_MODULE_NAME, "MQTT未连接，跳过属性上报");
            continue;
        }
        
        // 检查104桥接模块是否可用
        if (g_bridge == NULL) {
            LOG_DEBUG(LOG_MODULE_NAME, "104协议桥接模块未初始化，跳过属性上报");
            continue;
        }
        
        // 从104协议获取最新数据（这里使用模拟数据，实际应从104协议获取）
        // TODO: 实际应用中需要从104协议桥接模块获取真实数据
        // 例如：从遥测数据中获取储能站并网状态和停机状态
        
        // 模拟数据：储能站并网状态 (ESS_CS) 和 储能站停机状态 (ESS_SS)
        // 实际值应该从104协议的遥测/遥信数据中获取
        int ess_cs = 1;  // 储能站并网状态：1=并网，0=未并网
        int ess_ss = 0;  // 储能站停机状态：1=停机，0=运行
        
        // 将104协议数据转换为平台属性格式
        // 属性标识符：ESS_CS (储能站并网状态) 和 ESS_SS (储能站停机状态)
        char properties_json[512];
        snprintf(properties_json, sizeof(properties_json),
                 "{\"ESS_CS\":%d,\"ESS_SS\":%d}",
                 ess_cs, ess_ss);
        
        // 上报属性到平台
        int64_t report_time = (int64_t)time(NULL) * 1000;  // 毫秒时间戳
        platform_result_t result = platform_property_post(g_platform_client, report_time, properties_json);
        if (result == PLATFORM_SUCCESS) {
            LOG_INFO(LOG_MODULE_NAME, "属性上报成功: ESS_CS=%d, ESS_SS=%d", ess_cs, ess_ss);
        } else {
            LOG_WARN(LOG_MODULE_NAME, "属性上报失败，错误码: %d", result);
        }
    }
    
    LOG_INFO(LOG_MODULE_NAME, "属性上报线程退出");
    return NULL;
}

/**
 * @brief 启动属性上报线程
 */
static void start_property_report_thread(void) {
    if (g_property_report_thread != 0) {
        LOG_DEBUG(LOG_MODULE_NAME, "属性上报线程已在运行");
        return;
    }
    
    g_property_report_running = true;
    int ret = pthread_create(&g_property_report_thread, NULL, property_report_thread_func, NULL);
    if (ret != 0) {
        LOG_ERROR(LOG_MODULE_NAME, "创建属性上报线程失败，错误码: %d", ret);
        g_property_report_running = false;
    } else {
        LOG_INFO(LOG_MODULE_NAME, "属性上报线程已启动，每1分钟上报一次");
    }
}

/**
 * @brief 停止属性上报线程
 */
static void stop_property_report_thread(void) {
    if (g_property_report_thread == 0) {
        return;
    }
    
    LOG_INFO(LOG_MODULE_NAME, "停止属性上报线程...");
    g_property_report_running = false;
    
    // 等待线程结束（最多等待2秒）
    void* thread_result;
    int ret = pthread_join(g_property_report_thread, &thread_result);
    if (ret != 0) {
        LOG_WARN(LOG_MODULE_NAME, "等待属性上报线程结束失败，错误码: %d", ret);
    } else {
        LOG_DEBUG(LOG_MODULE_NAME, "属性上报线程已停止");
    }
    
    g_property_report_thread = 0;
}

static void gateway_cleanup(void) {
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    LOG_INFO(LOG_MODULE_NAME, "控制器正在关闭...");
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    
    // 停止属性上报线程
    stop_property_report_thread();
    
    // 停止协议桥接
    if (g_bridge) {
        LOG_INFO(LOG_MODULE_NAME, "停止协议桥接模块");
        iec104_protocol_bridge_stop(g_bridge);
        iec104_protocol_bridge_destroy(g_bridge);
        g_bridge = NULL;
    }
    
    // 销毁平台客户端（设备下线）
    if (g_platform_client) {
        LOG_INFO(LOG_MODULE_NAME, "设备下线...");
        // 如果设备已经注册，发送设备下线请求
        if (strlen(g_platform_config.device.product_key) > 0 &&
            strlen(g_platform_config.device.device_name) > 0 &&
            strlen(g_platform_config.device.device_secret) > 0) {
            platform_device_register_req_t unregister_req;
            memset(&unregister_req, 0, sizeof(unregister_req));
            generate_uuid(unregister_req.id, sizeof(unregister_req.id));
            safe_strncpy(unregister_req.type, "unregister", sizeof(unregister_req.type));
            safe_strncpy(unregister_req.device.product_key, g_platform_config.device.product_key, sizeof(unregister_req.device.product_key));
            safe_strncpy(unregister_req.device.device_name, g_platform_config.device.device_name, sizeof(unregister_req.device.device_name));
            safe_strncpy(unregister_req.device.device_secret, g_platform_config.device.device_secret, sizeof(unregister_req.device.device_secret));
            
            platform_device_unregister(g_platform_client, &unregister_req, NULL, NULL);
            // 等待一小段时间，让下线消息发送完成
            struct timespec ts = {0, 500000000}; // 500ms in nanoseconds
            nanosleep(&ts, NULL);
        }
        
        platform_client_destroy(g_platform_client);
        g_platform_client = NULL;
    }
    
    // 断开MQTT连接
    if (g_mqtt_client) {
        LOG_INFO(LOG_MODULE_NAME, "断开MQTT连接");
        mqtt_client_disconnect(g_mqtt_client);
        mqtt_client_destroy(g_mqtt_client);
        g_mqtt_client = NULL;
    }
    
    // 清理MQTT模块
    if (g_mqtt_config.connection.broker[0] != '\0') {
        mqtt_cleanup();
    }
    
    LOG_INFO(LOG_MODULE_NAME, "========================================");
    LOG_INFO(LOG_MODULE_NAME, "控制器已关闭");
    LOG_INFO(LOG_MODULE_NAME, "========================================");
}

/**
 * @brief 打印使用说明
 */
static void print_usage(const char* program) {
    printf("IoT平台与104协议控制器应用\n");
    printf("用法: %s [选项]\n", program);
    printf("选项:\n");
    printf("  -m <config>  指定MQTT配置文件 (默认: platform.conf)\n");
    printf("  -c <config>  指定104控制器配置文件 (默认: iec104_controller.conf)\n");
    printf("  -h           显示此帮助信息\n");
    printf("  -v           显示版本信息\n");
}

/**
 * @brief 打印版本信息
 */
static void print_version(void) {
    printf("IoT平台与104协议控制器 v1.0.0\n");
    printf("基于IEC 60870-5-104协议和MQTT协议\n");
}

/* ==================== 主函数 ==================== */

/**
 * @brief 主函数
 */
int main(int argc, char* argv[]) {
    const char* mqtt_config_file = "platform.conf";
    const char* iec104_config_file = "iec104_controller.conf";
    int opt;
    
    // 解析命令行参数
    while ((opt = getopt(argc, argv, "m:c:hv")) != -1) {
        switch (opt) {
            case 'm':
                mqtt_config_file = optarg;
                break;
            case 'c':
                iec104_config_file = optarg;
                break;
            case 'h':
                print_usage(argv[0]);
                return 0;
            case 'v':
                print_version();
                return 0;
            default:
                print_usage(argv[0]);
                return 1;
        }
    }
    
    // 设置信号处理
    setup_signal_handlers();
    
    // 初始化日志系统
    logger_init();  // 日志系统初始化，配置从环境或配置文件读取
    
    // 根据构建版本设置日志级别
    logger_set_level(LOG_LEVEL_DEFAULT);
    LOG_INFO(LOG_MODULE_NAME, "日志系统已初始化，日志级别: %d (DEBUG版本=%d, RELEASE版本=%d)", 
             LOG_LEVEL_DEFAULT, BUILD_VERSION_DEBUG, BUILD_VERSION_RELEASE);
    
    // 初始化控制器
    if (gateway_init(mqtt_config_file, iec104_config_file) != 0) {
        LOG_ERROR(LOG_MODULE_NAME, "控制器初始化失败");
        logger_cleanup();
        return 1;
    }
    
    // 主循环
    LOG_INFO(LOG_MODULE_NAME, "控制器运行中，按Ctrl+C退出...");
    time_t last_reconnect_time = 0;
    time_t last_status_print_time = 0;
    const int reconnect_interval = 300;  // 重连间隔：300秒（5分钟）
    const int status_print_interval = 60;  // 状态打印间隔：60秒（1分钟）
    
    while (g_running) {
        time_t current_time = time(NULL);
        
        // 定期打印连接状态（1分钟一次）
        bool should_print_status = (current_time - last_status_print_time >= status_print_interval || last_status_print_time == 0);
        
        // 定期检查MQTT连接状态（如果MQTT客户端存在）
        if (g_mqtt_client != NULL) {
            bool mqtt_connected = mqtt_client_is_connected(g_mqtt_client);
            
            // 定期打印MQTT连接状态（1分钟一次）
            if (should_print_status) {
                if (mqtt_connected) {
                    LOG_INFO(LOG_MODULE_NAME, "MQTT连接状态: CONNECTED");
                } else {
                    LOG_INFO(LOG_MODULE_NAME, "MQTT连接状态: DISCONNECTED");
                }
            }
            
            if (!mqtt_connected) {
                // 检查是否距离上次重连已经过了5分钟
                if (current_time - last_reconnect_time >= reconnect_interval || last_reconnect_time == 0) {
                    if (g_mqtt_client != NULL) {
                        LOG_WARN(LOG_MODULE_NAME, "MQTT连接断开，尝试重连...");
                        mqtt_result_t result = mqtt_client_connect(g_mqtt_client);
                        if (result != MQTT_SUCCESS) {
                            LOG_WARN(LOG_MODULE_NAME, "MQTT重连失败，错误码: %d，将在5分钟后再次尝试", result);
                        }
                        last_reconnect_time = current_time;
                    } else {
                        LOG_ERROR(LOG_MODULE_NAME, "MQTT客户端为空，无法重连");
                    }
                }
            } else {
                // 连接成功，重置重连时间
                last_reconnect_time = 0;
            }
        }
        
        // 定期打印104连接状态（1分钟一次）
        if (g_bridge != NULL && should_print_status) {
            LOG_INFO(LOG_MODULE_NAME, "104连接状态: %s", 
                     iec104_protocol_bridge_is_connected(g_bridge) ? "CONNECTED" : "DISCONNECTED");
        }
        
        // 更新状态打印时间
        if (should_print_status) {
            last_status_print_time = current_time;
        }
        
        // 休眠一段时间
        sleep(1);
    }
    
    // 清理资源
    gateway_cleanup();
    logger_cleanup();
    
    return 0;
}

